check dns

The code requires several modules for DNS operations and uses custom functions from a module named ../Core to perform tasks such as creating a Google Cloud DNS managed zone and inserting an address. The createZone function creates or retrieves a managed zone with a given subdomain, while the insertAddress function attempts to insert an address into the DNS managed zone.

Run example

check dns

What the code could have been:

```javascript
const dns = require('dns');
const { promisify } = require('util');
const { v1: uuid } = require('uuid');
const importer = require('../Core');
const authorizeGoogle = importer.import('authorize google service');
const listGlobalForwards = importer.import('list google bucket url map');
const waitForOperation = importer.import('wait cloud operation');

const host ='sheet-to-web.com';

function safeName(name) {
    if (typeof name!=='string') return '';

    return name.replace(/[^a-z0-9\-]/ig, '-').substr(0, 50).toLowerCase();
}

function createZone(client, project, subdomain) {
    return client.getRequest('GET', `https://www.googleapis.com/dns/v1/projects/${project}/managedZones`)
       .then(res => {
            if (res.data && res.data.managedZones && res.data.managedZones.length > 0) {
                const zone = res.data.managedZones[0];
                console.log(`Zone ${subdomain} already mapped`);
                return Promise.resolve(zone.name);
            }

            const zoneName = `mz-${uuid().substr(0, 5)}-${safeName(subdomain)}`;
            console.log(`Creating a zone for ${subdomain}`);

            return client.request({
                method: 'POST',
                url: `https://www.googleapis.com/dns/v1/projects/${project}/managedZones`,
                data: {
                    name: zoneName,
                    dnsName: subdomain + '.',
                    description: '',
                    visibility: 'public',
                    dnssecConfig: {
                        state: 'on',
                        kind: 'dns#managedZoneDnsSecConfig'
                    }
                }
            })
               .then(() => zoneName);
        });
}

function getZone(client, project, subdomain) {
    return client.getRequest('GET', `https://www.googleapis.com/dns/v1/projects/${project}/managedZones`)
       .then(res => {
            if (res.data && res.data.managedZones && res.data.managedZones.length > 0) {
                return res.data.managedZones.find(zone => zone.dnsName === subdomain + '.');
            }
            return null;
        });
}

function insertAddress(client, project, addrs, subdomain) {
    const zoneName = safeName(subdomain);
    const name = `ip-${uuid().substr(0, 5)}-${zoneName}`;
    let address = '';
    let records = [];

    return createZone(client, project, subdomain)
       .then(zone => {
            records = getRecords(client, project, zone.name, subdomain);
            return records;
        })
       .then(records => {
            const unusedIps = Object.keys(addrs).filter(a =>!records.some(r => r.rrdatas[0] === addrs[a]));
            if (unusedIps.length > 0) {
                address = addrs[unusedIps[0]];
                name = unusedIps[0];
                console.log(`New unused IP ${unusedIps[0]} exists`);
                return Promise.resolve({ name, address });
            }

            const defaultRecord = records.find(r => r.type === 'A' && r.name === host + '.');
            if (defaultRecord) {
                address = defaultRecord.rrdatas[0];
            }

            return client.createResourceRecordSet(client, project, zone.name, subdomain + '.', 'A', [address]);
        })
       .then(() => ({ name, address }));
}

function getRecords(client, project, zoneName, subdomain) {
    return client.getRequest('GET', `https://www.googleapis.com/dns/v1/projects/${project}/managedZones/${zoneName}/rrsets`)
       .then(res => res.data.rrsets.filter(r => r.type === 'A' && r.name === subdomain + '.'));
}

function addIP(project, subdomain) {
    const client = authorizeGoogle();
    const addresses = [];
    const { promisifiedLookup } = promisify(dns.lookup);
    const findExistingAddress = address => address.rrdatas[0];
    const findUnusedAddress = () => {
        const unusedIps = Object.keys(addresses).filter(a =>!getAddresses(client, project).some(addr => findExistingAddress(addr) === addresses[a]));
        return unusedIps.length > 0? unusedIps[0] : null;
    };

    return promisifiedLookup(subdomain)
       .catch(up => {
            if (up.message.includes('ENOTFOUND')) {
                console.log(up.message);
                return;
            }
            throw up;
        })
       .then(addrs => {
            addresses.push(addrs.address);
            return listGlobalForwards(project);
        })
       .then(forwards => {
            const matching = Object.keys(forwards).filter(a => addresses.indexOf(forwards[a]) > -1);
            if (matching.length > 0) {
                console.log(`domain ${subdomain} already exists, ip address ${matching[0]}`);
                return Promise.resolve(matching[0]);
            }
            return insertAddress(client, project, addresses, subdomain);
        });
}

function clientRequest(client, method, url, data) {
    return client.request({
        method,
        url,
        data
    });
}

function clientGetRequest(client, url) {
    return client.getRequest('GET', url);
}

module.exports = addIP;
```

Requirements and Imports

Constants and Functions

createZone Function

insertAddress Function

Note that the code snippet is incomplete, and the insertAddress function is not fully implemented.